
// Compiler implementation of the D programming language
// Copyright (c) 1999-2007 by Digital Mars
// All Rights Reserved
// written by Walter Bright
// http://www.digitalmars.com
// License for redistribution is by either the Artistic License
// in artistic.txt, or the GNU General Public License in gnu.txt.
// See the included readme.txt for details.

#include <stdio.h>
#include <assert.h>

#include "mars.h"
#include "dsymbol.h"
#include "mtype.h"
#include "scope.h"
#include "init.h"
#include "expression.h"
#include "attrib.h"
#include "declaration.h"
#include "template.h"
#include "../l_neo_lexer/id.h"
#include "enum.h"
#include "import.h"
#include "aggregate.h"

//@ for debug
#include <windows.h>

#if V2

/* Do mangling for C++ linkage.
 * Follows Itanium C++ ABI 1.86
 * No attempt is made to support mangling of templates, operator
 * overloading, or special functions.
 *
 * So why don't we use the C++ ABI for D name mangling?
 * Because D supports a lot of things (like modules) that the C++
 * ABI has no concept of. These affect every D mangled name,
 * so nothing would be compatible anyway.
 */

struct CppMangleState
{
    static Array components;

    int substitute(OutBuffer *buf, void *p);
};

Array CppMangleState::components;


void writeBase36(OutBuffer *buf, unsigned i)
{
    if (i >= 36)
    {
	writeBase36(buf, i / 36);
	i %= 36;
    }
    if (i < 10)
	buf->writeByte(i + '0');
    else if (i < 36)
	buf->writeByte(i - 10 + 'A');
    else
	assert(0);
}

int CppMangleState::substitute(OutBuffer *buf, void *p)
{
    for (size_t i = 0; i < components.dim; i++)
    {
	if (p == components.data[i])
	{
	    /* Sequence is S_, S0_, .., S9_, SA_, ..., SZ_, S10_, ...
	     */
	    buf->writeByte('S');
	    if (i)
		writeBase36(buf, i - 1);
	    buf->writeByte('_');
	    return 1;
	}
    }
    components.push(p);
    return 0;
}

void source_name(OutBuffer *buf, P_Dsymbol *s)
{
    char *name = s->ident->oToChars();
    buf->printf("%d%s", strlen(name), name);
}

void prefix_name(OutBuffer *buf, CppMangleState *cms, P_Dsymbol *s)
{
    if (!cms->substitute(buf, s))
    {
	P_Dsymbol *p = s->toParent();
	if (p && !p->isModule())
	{
	    prefix_name(buf, cms, p);
	}
	source_name(buf, s);
    }
}

void cpp_mangle_name(OutBuffer *buf, CppMangleState *cms, P_Dsymbol *s)
{
    P_Dsymbol *p = s->toParent();
    if (p && !p->isModule())
    {
	buf->writeByte('N');

	P_FuncDeclaration *fd = s->isFuncDeclaration();
	if (fd->isConst())
	    buf->writeByte('K');

	prefix_name(buf, cms, p);
	source_name(buf, s);

	buf->writeByte('E');
    }
    else
	source_name(buf, s);
}


char *cpp_mangle(P_Dsymbol *s)
{
    /*
     * <mangled-name> ::= _Z <encoding>
     * <encoding> ::= <function name> <bare-function-type>
     *	       ::= <data name>
     *	       ::= <special-name>
     */

    CppMangleState cms;
    memset(&cms, 0, sizeof(cms));
    cms.components.setDim(0);

    OutBuffer buf;
#if MACHOBJ
    buf.writestring("__Z");
#else
    buf.writestring("_Z");
#endif

    cpp_mangle_name(&buf, &cms, s);

    P_FuncDeclaration *fd = s->isFuncDeclaration();
    if (fd)
    {	// add <bare-function-type>
	TypeFunction *tf = (TypeFunction *)fd->type;
	assert(tf->ty == Tfunction);
	
	//@Argument::argsCppMangle(&buf, &cms, tf->parameters, tf->varargs);
	MessageBox(0, "Argument::argsCppMangle", "error", MB_OK);
    
	}
    buf.writeByte(0);
    return (char *)buf.extractData();
}

/* ============= Type Encodings ============================================= */
#if TARGET_LINUX || TARGET_OSX
void Type::toCppMangle(OutBuffer *buf, CppMangleState *cms)
{
    /* Make this the 'vendor extended type' when there is no
     * C++ analog.
     * u <source-name>
     */
    if (!cms->substitute(buf, this))
    {	assert(deco);
	buf->printf("u%d%s", strlen(deco), deco);
    }
}
#endif

#if TARGET_LINUX || TARGET_OSX
void TypeBasic::toCppMangle(OutBuffer *buf, CppMangleState *cms)
{   char c;
    char p = 0;

    /* ABI spec says:
     * v	void
     * w	wchar_t
     * b	bool
     * c	char
     * a	signed char
     * h	unsigned char
     * s	short
     * t	unsigned short
     * i	int
     * j	unsigned int
     * l	long
     * m	unsigned long
     * x	long long, __int64
     * y	unsigned long long, __int64
     * n	__int128
     * o	unsigned __int128
     * f	float
     * d	double
     * e	long double, __float80
     * g	__float128
     * z	ellipsis
     * u <source-name>	# vendor extended type
     */

    switch (ty)
    {
	case Tvoid:	c = 'v';	break;
	case Tint8:	c = 'a';	break;
	case Tuns8:	c = 'h';	break;
	case Tint16:	c = 's';	break;
	case Tuns16:	c = 't';	break;
	case Tint32:	c = 'i';	break;
	case Tuns32:	c = 'j';	break;
	case Tfloat32:	c = 'f';	break;
	case Tint64:	c = 'x';	break;
	case Tuns64:	c = 'y';	break;
	case Tfloat64:	c = 'd';	break;
	case Tfloat80:	c = 'e';	break;
	case Tbool:	c = 'b';	break;
	case Tchar:	c = 'c';	break;
	case Twchar:	c = 't';	break;
	case Tdchar:	c = 'w';	break;

	case Timaginary32: p = 'G'; c = 'f';	break;
	case Timaginary64: p = 'G'; c = 'd';	break;
	case Timaginary80: p = 'G'; c = 'e';	break;
	case Tcomplex32:   p = 'C'; c = 'f';	break;
	case Tcomplex64:   p = 'C'; c = 'd';	break;
	case Tcomplex80:   p = 'C'; c = 'e';	break;

	default:	assert(0);
    }
    if (p)
    {
	if (cms->substitute(buf, this))
	    return;
	buf->writeByte(p);
    }
    buf->writeByte(c);
}
#endif

#if TARGET_LINUX || TARGET_OSX
void TypeSArray::toCppMangle(OutBuffer *buf, CppMangleState *cms)
{
    if (!cms->substitute(buf, this))
    {	buf->printf("A%ju_", dim ? dim->toInteger() : 0);
	next->toCppMangle(buf, cms);
    }
}
#endif

#if TARGET_LINUX || TARGET_OSX
void TypeDArray::toCppMangle(OutBuffer *buf, CppMangleState *cms)
{
    Type::toCppMangle(buf, cms);
}
#endif

#if TARGET_LINUX || TARGET_OSX
void TypeAArray::toCppMangle(OutBuffer *buf, CppMangleState *cms)
{
    Type::toCppMangle(buf, cms);
}
#endif

#if TARGET_LINUX || TARGET_OSX
void TypePointer::toCppMangle(OutBuffer *buf, CppMangleState *cms)
{
    if (!cms->substitute(buf, this))
    {	buf->writeByte('P');
	next->toCppMangle(buf, cms);
    }
}
#endif

#if TARGET_LINUX || TARGET_OSX
void TypeReference::toCppMangle(OutBuffer *buf, CppMangleState *cms)
{
    if (!cms->substitute(buf, this))
    {	buf->writeByte('R');
	next->toCppMangle(buf, cms);
    }
}
#endif

#if TARGET_LINUX || TARGET_OSX
void TypeFunction::toCppMangle(OutBuffer *buf, CppMangleState *cms)
{   /*
     *	<function-type> ::= F [Y] <bare-function-type> E
     *	<bare-function-type> ::= <signature type>+
     *	# types are possible return type, then parameter types
     */

    /* ABI says:
	"The type of a non-static member function is considered to be different,
	for the purposes of substitution, from the type of a namespace-scope or
	static member function whose type appears similar. The types of two
	non-static member functions are considered to be different, for the
	purposes of substitution, if the functions are members of different
	classes. In other words, for the purposes of substitution, the class of
	which the function is a member is considered part of the type of
	function."

	BUG: Right now, types of functions are never merged, so our simplistic
	component matcher always finds them to be different.
	We should use Type::equals on these, and use different
	TypeFunctions for non-static member functions, and non-static
	member functions of different classes.
     */
    if (!cms->substitute(buf, this))
    {
	buf->writeByte('F');
	if (linkage == LINKc)
	    buf->writeByte('Y');
	next->toCppMangle(buf, cms);
	Argument::argsCppMangle(buf, cms, parameters, varargs);
	buf->writeByte('E');
    }
}
#endif

#if TARGET_LINUX || TARGET_OSX
void TypeDelegate::toCppMangle(OutBuffer *buf, CppMangleState *cms)
{
    Type::toCppMangle(buf, cms);
}
#endif

#if TARGET_LINUX || TARGET_OSX
void TypeStruct::toCppMangle(OutBuffer *buf, CppMangleState *cms)
{
    if (!cms->substitute(buf, sym))
	cpp_mangle_name(buf, cms, sym);
}
#endif

#if TARGET_LINUX || TARGET_OSX
void TypeEnum::toCppMangle(OutBuffer *buf, CppMangleState *cms)
{
    if (!cms->substitute(buf, sym))
	cpp_mangle_name(buf, cms, sym);
}
#endif

#if TARGET_LINUX || TARGET_OSX
void TypeTypedef::toCppMangle(OutBuffer *buf, CppMangleState *cms)
{
    Type::toCppMangle(buf, cms);
}
#endif

#if TARGET_LINUX || TARGET_OSX
void TypeClass::toCppMangle(OutBuffer *buf, CppMangleState *cms)
{
    if (!cms->substitute(buf, this))
    {	buf->writeByte('P');
	if (!cms->substitute(buf, sym))
	    cpp_mangle_name(buf, cms, sym);
    }
}
#endif

#if TARGET_LINUX || TARGET_OSX
void Argument::argsCppMangle(OutBuffer *buf, CppMangleState *cms, Arguments *arguments, int varargs)
{   int n = 0;
    if (arguments)
    {
	for (size_t i = 0; i < arguments->dim; i++)
	{   Argument *arg = (Argument *)arguments->data[i];
	    Type *t = arg->type;
	    if (arg->storageClass & (STCout | STCref))
		t = t->referenceTo();
	    else if (arg->storageClass & STClazy)
	    {	// Mangle as delegate
		Type *td = new TypeFunction(NULL, t, 0, LINKd);
		td = new TypeDelegate(td);
		t = t->merge();
	    }
	    if (t->ty == Tsarray)
	    {	// Mangle static arrays as pointers
		t = t->pointerTo();
	    }
	    t->toCppMangle(buf, cms);

	    n++;
	}
    }
    if (varargs)
	buf->writestring("z");
    else if (!n)
	buf->writeByte('v');		// encode ( ) arguments
}
#endif

#endif

